import request from '@/utils/request'
import { getToken } from '@/utils/auth'

// 获取API基础URL，与request.js保持一致
const baseURL = process.env.VUE_APP_BASE_API || '/api'

/**
 * 发送聊天消息（流式）
 * @param {Object} params
 * @param {string} params.query - 用户输入
 * @param {string} params.user - 用户标识
 * @param {string} params.conversation_id - 会话ID（可选）
 * @param {Array} params.files - Chatflow 文件上传列表（存储在 sys.files），用于多模态对话（可选）
 * @param {Object} params.inputs - 工作流输入变量（包括文件变量），存储在自定义变量（可选）
 * @param {AbortSignal} params.signal - 中断信号（可选）
 * @param {Function} onMessage - 消息回调
 * @param {Function} onEnd - 结束回调
 * @param {Function} onError - 错误回调
 * @returns {Object} 返回包含 reader 的对象，用于手动中断
 */
export function sendChatMessage({ query, user, conversation_id, files = [], inputs, signal, appName }, onMessage, onEnd, onError) {
  // 构建后端期望的请求体格式
  const requestData = {
    message: query,
    userId: user,
    conversationId: conversation_id || null,
    createNewConversation: !conversation_id,
    files: files || []
  }

  // 添加 App名称（如果提供）
  if (appName) {
    requestData.appName = appName
    console.log('🔑 使用 App名称:', appName)
  }

  // 添加 inputs（如果提供）
  if (inputs !== undefined && inputs !== null) {
    // 注意：后端可能需要在其他字段中传递 inputs，这里先保留以备后用
    requestData.inputs = inputs
    const inputKeys = Object.keys(inputs)
    if (inputKeys.length > 0) {
      console.log('🔧 API - 添加 inputs 到请求体:', inputKeys.join(', '))
    }
  }

  // 打印最终的请求体（调试用）
  console.log('🌐 发送到后端API的请求体:', JSON.stringify(requestData, null, 2))

  let isAborted = false
  const xhr = new XMLHttpRequest()
  
  xhr.open('POST', `${baseURL}/api/ai/chat/send/stream`, true)
  xhr.setRequestHeader('Content-Type', 'application/json')
  xhr.setRequestHeader('Accept', 'text/event-stream')
  
  // 添加token到请求头，使后端能够解析到用户信息
  const token = getToken()
  if (token) {
    xhr.setRequestHeader('token', token)
    console.log('🔑 已添加token到请求头')
  }
  
  if ('withCredentials' in xhr) {
    xhr.withCredentials = false
  }

  // 改进的SSE数据解析，处理数据分割问题
  let lastIndex = 0
  let buffer = ''
  let accumulatedContent = '' // 累积的消息内容
  let finalData = {} // 累积最终数据（包括 files、metadata 等）
  let isDone = false // 标记是否已完成，避免重复调用 onEnd
  
  const processChunk = () => {
    const newData = xhr.responseText.substring(lastIndex)
    if (!newData) return
    lastIndex = xhr.responseText.length
    
    // 将新数据添加到缓冲区
    buffer += newData
    
    // 按双换行符分割SSE消息（SSE标准格式）
    const messages = buffer.split('\n\n')
    
    // 保留最后一条消息（可能不完整）
    buffer = messages.pop() || ''

    // 处理完整的消息
    for (let message of messages) {
      if (!message.trim()) continue
      
      // 解析SSE消息（可能包含多行）
      const lines = message.split('\n')
      let dataContent = ''
      
      for (let line of lines) {
        line = line.trim()
        if (line.startsWith('data:')) {
          // 提取 data: 后的内容
          const content = line.substring(5).trim()
          dataContent += content
        }
      }
      
      if (!dataContent) continue
      
      // 处理特殊标记
      if (dataContent === '[DONE]') {
        if (!isDone) {
          console.log('📋 [chat.js] SSE流完成，最终数据:', finalData)
          onEnd && onEnd(finalData)
          isDone = true
        }
        return
      }
      
      // 解析JSON数据
      try {
        const parsed = JSON.parse(dataContent)
        
        // 处理错误
        if (parsed.error) {
          onError && onError({
            event: 'error',
            message: parsed.error
          })
          return
        }
        
        // 收集所有数据到 finalData
        if (parsed.conversation_id) {
          finalData.conversation_id = parsed.conversation_id
        }
        if (parsed.task_id) {
          finalData.task_id = parsed.task_id
        }
        if (parsed.metadata) {
          finalData.metadata = parsed.metadata
        }
        if (parsed.files) {
          console.log('📎 [chat.js] 收到 files 数据:', parsed.files)
          finalData.files = parsed.files
        }
        
        // 处理会话ID
        if (parsed.conversationId || parsed.conversation_id) {
          const convId = parsed.conversationId || parsed.conversation_id
          onMessage && onMessage({
            event: 'conversation',
            conversation_id: convId
          })
        }
        
        // 处理内容（后端返回格式：{"content":"..."}）
        if (parsed.content !== undefined) {
          accumulatedContent += parsed.content
          // 转换为 Dify 格式的事件
          onMessage && onMessage({
            event: 'message',
            answer: parsed.content, // 增量内容
            task_id: parsed.task_id || null
          })
        }
        
        // 处理 type: conversation 格式
        if (parsed.type === 'conversation' && parsed.conversationId) {
          onMessage && onMessage({
            event: 'conversation',
            conversation_id: parsed.conversationId
          })
        }
      } catch (e) {
        console.log('SSE JSON解析失败:', dataContent, '错误:', e.message)
      }
    }
  }
  
  xhr.onprogress = processChunk
  xhr.onreadystatechange = function() {
    if (xhr.readyState === 4) {
      if (xhr.status === 200) {
        // 处理最后的缓冲区数据
        if (buffer.trim()) {
          processChunk()
        }
        // 如果还没有触发 onEnd（没有收到 [DONE]），现在触发
        if (!isDone) {
          console.log('📋 [chat.js] XHR 完成，最终数据:', finalData)
          onEnd && onEnd(finalData)
          isDone = true
        }
      } else if (xhr.status !== 0) {
        // 请求失败
        onError && onError({
          event: 'error',
          message: `HTTP error! status: ${xhr.status}`
        })
      }
    }
  }
  
  xhr.onerror = function() {
    onError && onError({
      event: 'error',
      message: '网络错误'
    })
  }
  
  // 支持 AbortSignal
  if (signal) {
    signal.addEventListener('abort', () => {
      isAborted = true
      xhr.abort()
    })
  }
  
  xhr.send(JSON.stringify(requestData))

  return {
    abort: () => {
      isAborted = true
      xhr.abort()
    }
  }
}

/**
 * 上传文件 - 通过后端接口中转
 * @param {File} file - 文件对象
 * @param {string} user - 用户标识
 * @param {string} appName - App名称（可选）
 */
export async function uploadFile(file, user, appName = null) {
  const formData = new FormData()
  formData.append('file', file)
  formData.append('userId', user)
  
  // 如果提供了 appName，添加到 FormData
  if (appName) {
    formData.append('appName', appName)
  }

  return request({
    url: '/api/ai/chat/upload',
    method: 'post',
    data: formData
    // 注意：不要手动设置 Content-Type，让浏览器自动设置（包含 boundary）
    // 手动设置会导致请求格式错误
  })
}

/**
 * 获取会话列表 - 通过后端接口中转
 * @param {string} user - 用户标识
 * @param {number} limit - 返回数量
 * @param {string} appName - App名称（可选）
 */
export async function getConversations(user, limit = 20, appName = null) {
  const params = { userId: user, limit }
  if (appName) {
    params.appName = appName
  }
  return request({
    url: '/api/ai/chat/conversations',
    method: 'get',
    params
  })
}

/**
 * 获取会话历史消息 - 通过后端接口中转
 * @param {string} conversation_id - 会话ID
 * @param {string} user - 用户标识
 * @param {number} limit - 返回数量
 * @param {string} appName - App名称（可选）
 */
export async function getMessages(conversation_id, user, limit = 20, appName = null) {
  const params = { userId: user, limit }
  if (appName) {
    params.appName = appName
  }
  return request({
    url: `/api/ai/chat/conversations/${conversation_id}/messages`,
    method: 'get',
    params
  })
}

/**
 * 删除会话 - 通过后端接口中转
 * @param {string} conversation_id - 会话ID
 * @param {string} user - 用户标识
 * @param {string} appName - App名称（可选）
 */
export async function deleteConversation(conversation_id, user, appName = null) {
  const params = { userId: user }
  if (appName) {
    params.appName = appName
  }
  return request({
    url: `/api/ai/chat/dify/conversations/${conversation_id}`,
    method: 'delete',
    params
  })
}

/**
 * 重命名会话 - 通过后端接口中转
 * @param {string} conversation_id - 会话ID
 * @param {string} name - 新名称
 * @param {string} user - 用户标识
 * @param {boolean} auto_generate - 是否自动生成
 */
export async function renameConversation(conversation_id, name, user, auto_generate = false) {
  return request({
    url: `/api/ai/chat/dify/conversations/${conversation_id}/name`,
    method: 'post',
    params: { userId: user, name, autoGenerate: auto_generate }
  })
}

/**
 * 停止响应 - 通过后端接口中转
 * @param {string} task_id - 任务ID
 * @param {string} user - 用户标识
 */
export async function stopChatMessage(task_id, user) {
  return request({
    url: `/api/ai/chat/dify/chat-messages/${task_id}/stop`,
    method: 'post',
    params: { userId: user }
  })
}

/**
 * 获取应用参数 - 通过后端接口中转
 * @param {string} appName - App名称（可选）
 * 注意：如果后端没有提供此接口，可能需要调用Dify API或返回空对象
 */
export async function getAppParameters(appName) {
  // 如果后端没有提供此接口，可以返回空对象或调用Dify API
  // 暂时返回空对象，需要根据实际后端接口调整
  try {
    const params = {}
    if (appName) {
      params.appName = appName
    }
    return request({
      url: '/api/ai/chat/dify/parameters',
      method: 'get',
      params
    })
  } catch (error) {
    console.warn('获取应用参数接口不存在，返回空对象')
    return { data: {} }
  }
}

/**
 * 获取下一轮建议问题列表 - 通过后端接口中转
 * 注意：如果后端没有提供此接口，可能需要调用Dify API或返回空数组
 * @param {string} message_id - 消息ID
 * @param {string} user - 用户标识
 */
export async function getSuggestedQuestions(message_id, user) {
  // 如果后端没有提供此接口，可以返回空数组或调用Dify API
  // 暂时返回空数组，需要根据实际后端接口调整
  try {
    return request({
      url: `/api/ai/chat/dify/messages/${message_id}/suggested`,
      method: 'get',
      params: { userId: user }
    })
  } catch (error) {
    console.warn('获取建议问题接口不存在，返回空数组')
    return { data: [] }
  }
}

